// utils/request.js
import { BASE_URL } from "./netConstants"
// 基础配置
const TIMEOUT = 15000 // 请求超时时间

// 请求队列（用于取消请求）
const requestQueue = new Map()

/**
 * 封装uni.request请求
 * @param {Object} options 请求配置
 * @returns {Promise} 返回Promise对象
 */
const http = (options = {}) => {
	let token=uni.getStorageSync("token");
  // 合并配置参数
  options = Object.assign({
    url: '',
    method: 'GET',
    data: {},
    header: {
		'Authorization':token,
		'companyid':'1870655092632494082'
	},
    timeout: TIMEOUT,
    loading: true, // 默认显示加载提示
    auth: true,    // 默认需要token验证
    unique: true   // 默认取消重复请求
  }, options)

  // 处理完整URL
  if (!options.url.startsWith('http')) {
    options.url = BASE_URL + options.url
  }

  // 请求拦截器
  return new Promise((resolve, reject) => {
    // 显示加载提示
    if (options.loading) {
      uni.showLoading({ title: '加载中...', mask: true })
    }

    // 添加token到header
    if (options.auth) {
      const token = uni.getStorageSync('token')
      if (token) {
        options.header.Authorization = `Bearer ${token}`
      }
    }

    // 取消重复请求
    if (options.unique) {
      const requestKey = `${options.method}_${options.url}`
      if (requestQueue.has(requestKey)) {
        const prevTask = requestQueue.get(requestKey)
        prevTask.abort()
        requestQueue.delete(requestKey)
      }
      
      // 创建任务控制器
      const task = uni.request({
        ...options,
        success: (res) => {
          // 响应拦截器
          handleResponse(res, resolve, reject)
        },
        fail: (err) => {
          // 错误处理
          handleError(err, reject)
        },
        complete: () => {
          // 清理请求队列
          requestQueue.delete(requestKey)
          if (options.loading) uni.hideLoading()
        }
      })
      
      // 加入请求队列
      requestQueue.set(requestKey, task)
    } else {
      // 不检查重复请求
      uni.request({
        ...options,
        success: (res) => handleResponse(res, resolve, reject),
        fail: (err) => handleError(err, reject),
        complete: () => { if (options.loading) uni.hideLoading() }
      })
    }
  })
}

/**
 * 响应拦截处理
 */
function handleResponse(res, resolve, reject) {
  const { statusCode, data } = res
  
  if (statusCode === 200) {
    // 根据业务状态码处理（示例：1000表示成功）
    if (data.code === 200) {
      resolve(data.data)
    } else {
      // 特殊状态码处理（如token过期）
      if (data.code === 401) {
        handleTokenExpired()
        return reject(new Error('登录已过期'))
      }
      
      // 显示业务错误信息
      uni.showToast({ title: data.msg || '业务错误', icon: 'none' })
      reject(data)
    }
  } else {
    // HTTP状态码错误处理
    const errorMap = {
      400: '请求错误',
      401: '未授权',
      403: '禁止访问',
      404: '资源不存在',
      500: '服务器错误'
    }
    const errMsg = errorMap[statusCode] || `请求失败，状态码：${statusCode}`
    uni.showToast({ title: errMsg, icon: 'none' })
    reject(res)
  }
}

/**
 * 错误处理
 */
function handleError(err, reject) {
  // 网络错误处理
  if (err.errMsg.includes('timeout')) {
    uni.showToast({ title: '请求超时', icon: 'none' })
  } else if (err.errMsg.includes('abort')) {
    console.log('请求被取消')
  } else {
    uni.showToast({ title: '网络异常，请重试', icon: 'none' })
  }
  reject(err)
}

/**
 * Token过期处理
 */
function handleTokenExpired() {
  uni.showModal({
    title: '提示',
    content: '登录已过期，请重新登录',
    showCancel: false,
    success: () => {
      // 清除token并跳转到登录页
      uni.removeStorageSync('token')
      uni.reLaunch({ url: '/pages/login/index' })
    }
  })
}

// 快捷方法封装
const methods = ['GET', 'POST', 'PUT', 'DELETE']
methods.forEach(method => {
  http[method.toLowerCase()] = (url, data, config) => {
    return http({ url, method, data, ...config })
  }
})

export default http